《面向对象程序设计(Java)》期末试卷B (精选01)

一、选择题（共 20 题，每题 1.5 分，共 30 分）

1．有一段 Java 应用程序，它的主类名是 a1，那么保存它的源文件名可以是（）

A. a1.java
B. a1.class
C. a1
D. 都对

查看答案与解析

答案：A

解析：

Java 源文件名必须与 public 修饰的类名一致，扩展名为 .java。
.class 是编译后的字节码文件，B 错误。
源文件必须有扩展名，C 错误。
不是都对，D 错误。

难度: ⭐ 考点: #源文件命名 #javac

💡 学习锦囊

📖 相关公式与知识点:

源文件命名规则：public 类的源文件名必须与类名一致，扩展名为 .java
编译命令：javac 源文件名.java → 生成 .class 字节码文件

易错点

源文件必须有 .java 扩展名，不能省略
一个源文件中只能有一个 public 类

🔄 举一反三

如果主类名是 HelloWorld，正确的源文件名是什么？
查看练习答案与解析
答案：HelloWorld.java解析：Java 源文件名必须与 public 类名完全一致（区分大小写），扩展名为 .java。

2．能正确表示 a 和 b 同时为正或同时为负的逻辑表达式是（）

A. (a >= 0 || b >= 0) && (a < 0 || b < 0)
B. (a >= 0 && b >= 0) && (a < 0 && b < 0)
C. a + b > 0
D. a * b > 0

查看答案与解析

答案：D

解析： "a 和 b 同时为正或同时为负"即 a 和 b 同号。

A：(a >= 0 || b >= 0) && (a < 0 || b < 0) → 一正一负时为 true，错误。
B：(a >= 0 && b >= 0) && (a < 0 && b < 0) → 永远为 false，错误。
C：a + b > 0 → 两负相加为负，不能表示同号，错误。
D：a * b > 0 → 同号相乘为正，正确 ✓

难度: ⭐⭐ 考点: #逻辑表达式 #同号判断

💡 学习锦囊

📖 相关公式与知识点:

同号判断：a * b > 0 表示 a 和 b 同号
异号判断：a * b < 0 表示 a 和 b 异号
逻辑运算符：&&（逻辑与）、||（逻辑或）、!（逻辑非）

易错点

a + b > 0 不能判断同号（两负相加可能为负）
选项 B 中两个互斥条件用 && 连接，永远为 false

🔄 举一反三

如何判断 a 和 b 异号？
查看练习答案与解析
答案：a * b < 0解析：异号相乘为负，所以 a * b < 0 表示 a 和 b 异号。也可以用 (a > 0 && b < 0) || (a < 0 && b > 0)。

3．访问控制符作用范围由大到小是（）

A. private → default → protected → public
B. public → default → protected → private
C. private → protected → default → public
D. public → protected → default → private

查看答案与解析

答案：D

解析： 访问控制符作用范围从大到小：public → protected → default → private

修饰符	同类	同包	子类	不同包
public	✓	✓	✓	✓
protected	✓	✓	✓	✗
default	✓	✓	✗	✗
private	✓	✗	✗	✗

难度: ⭐ 考点: #访问控制符 #public #protected #private

💡 学习锦囊

📖 相关公式与知识点:

public：任何地方都可访问
protected：同包 + 不同包子类可访问
default（缺省）：仅同包可访问
private：仅本类可访问

易错点

记忆口诀：public > protected > default > private
default 不是关键字，是不写修饰符时的默认访问级别

🔄 举一反三

如果一个类的成员没有写访问修饰符，它的访问范围是什么？
查看练习答案与解析
答案：同包内的类都可以访问（default 访问级别）解析：不写访问修饰符即为 default（缺省）访问级别，同包内的类都可以访问，不同包的类（包括子类）不能访问。

4．定义了 int 型二维数组 a[6][7] 后，数组元素 a[3][4] 前的数组元素个数为（）

A. 24
B. 25
C. 18
D. 17

查看答案与解析

答案：B

解析： Java 二维数组按行优先存储。a[3][4] 前的元素包括：

前 3 行完整元素：3 × 7 = 21 个
第 4 行前 4 个元素：4 个
总计：21 + 4 = 25 个

公式：行号 × 列数 + 列号 = 3 × 7 + 4 = 25

难度: ⭐⭐ 考点: #二维数组 #行优先存储

💡 学习锦囊

📖 相关公式与知识点:

二维数组元素计数：a[m][n] 前的元素个数 = m × 列数 + n
行优先存储：先存完一行再存下一行

易错点

注意数组下标从 0 开始，a[3][4] 是第 4 行第 5 个元素
不要忘记第 4 行（下标3）前面 4 个元素也要计入

🔄 举一反三

定义 int a[5][6]，a[2][3] 前有多少个元素？
查看练习答案与解析
答案：15 解析：2 × 6 + 3 = 15。前 2 行共 12 个元素，第 3 行前 3 个元素，共 15 个。

5．以下关于继承的叙述正确的是（）

A. 在 Java 中类只允许单一继承
B. 在 Java 中一个类只能实现一个接口
C. 在 Java 中一个类不能同时继承一个类和实现一个接口
D. 在 Java 中接口只允许单一继承

查看答案与解析

答案：A

解析：

A 正确：Java 类只允许单继承（一个类只能有一个直接父类）。
B 错误：一个类可以实现多个接口。
C 错误：一个类可以同时继承一个类并实现多个接口。
D 错误：接口允许多继承（一个接口可以继承多个接口）。

难度: ⭐ 考点: #继承 #单继承 #接口多继承

💡 学习锦囊

📖 相关公式与知识点:

类继承：Java 类只支持单继承（extends 一个父类）
接口实现：一个类可以实现多个接口（implements Interface1, Interface2）
接口继承：接口支持多继承（extends Interface1, Interface2）

易错点

类是单继承，接口是多继承，不要混淆
一个类可以同时 extends 一个类和 implements 多个接口

🔄 举一反三

定义一个类同时继承一个类并实现两个接口，语法格式是什么？
查看练习答案与解析
答案：class MyClass extends ParentClass implements Interface1, Interface2 { }解析：先 extends 继承类，再 implements 实现接口，多个接口用逗号分隔。

6．下列程序执行完后，正确的结果是（）

java

public class TestAnd {
    public static void main(String[] args) {
        int x = 0;
        int y = 3;
        if (x != 0 && y == y / x)
            ;
        System.out.println("y = " + y);
    }
}

A. 0
B. 3
C. 程序运行出错
D. 5

查看答案与解析

答案：B

解析：&& 是短路逻辑与。x != 0 为 false（x=0），短路后 y == y / x 不执行，不会发生除零错误。y 保持不变，输出 y = 3。

难度: ⭐⭐ 考点: #短路逻辑 #&& #逻辑与

💡 学习锦囊

📖 相关公式与知识点:

短路逻辑与 &&：第一个操作数为 false，则不计算第二个操作数
短路逻辑或 ||：第一个操作数为 true，则不计算第二个操作数
非短路逻辑与 &：两个操作数都会计算

易错点

&& 短路可以避免除零错误，但 & 不会短路
如果将 && 改为 &，则会抛出 ArithmeticException

🔄 举一反三

如果将 && 改为 &，程序会怎样？
查看练习答案与解析
答案：程序运行出错（ArithmeticException: / by zero）解析：& 是非短路逻辑与，两边都会计算。y / x 即 3 / 0，抛出除零异常。

7．下列有关 Java 布尔类型的描述中，正确的是（）

A. 一种基本的数据类型，它的类型名称为 boolean
B. 用 int 表示类型
C. 其值可以赋给 int 类型的变量
D. 有两个值，1 代表真，0 代表假

查看答案与解析

答案：A

解析：

A 正确：boolean 是 Java 的基本数据类型。
B 错误：boolean 不是 int。
C 错误：boolean 值不能赋给 int 变量（Java 严格区分）。
D 错误：boolean 值是 true 和 false，不是 1 和 0。

难度: ⭐ 考点: #boolean类型 #基本数据类型

💡 学习锦囊

📖 相关公式与知识点:

boolean：Java 基本数据类型，值为 true 或 false
Java 的 boolean 与 C/C++ 不同，不能与 int 互换

易错点

Java 的 boolean 不等于 C 的 0/1
boolean 值不能赋给 int 变量，int 值也不能赋给 boolean 变量

🔄 举一反三

下列哪个赋值语句在 Java 中是合法的？
- A. boolean b = 1;
- B. boolean b = true;
- C. int x = false;
- D. boolean b = (3 > 2) ? 1 : 0;
查看练习答案与解析
答案：B 解析：A 中 1 是 int 不能赋给 boolean；B 正确；C 中 false 不能赋给 int；D 中三元表达式结果是 int 不是 boolean。

8．设 a、b 和 c 都是 int 型变量，且 a = 3，b = 4，c = 5，则下列表达式中，值为 0 的是（）

A. a & b
B. a <= b ? 1 : 0
C. a | b + c & b - c
D. !((a < b) && c != 0 || true) ? 0 : 1

查看答案与解析

答案：A

解析： a=3, b=4, c=5。

A：a & b = 3 & 4 = 0b011 & 0b100 = 0 ✓
B：a <= b ? 1 : 0 = 3 <= 4 ? 1 : 0 = 1 ✗
C：a | b + c & b - c，按运算符优先级（+/- > & > |）等价于 3 | ((4+5) & (4-5)) = 3 | (9 & (-1)) = 3 | 9 = 11 ✗
D：!((a < b) && c != 0 || true) ? 0 : 1 = !(true && true || true) ? 0 : 1 = !true ? 0 : 1 = false ? 0 : 1 = 1 ✗

难度: ⭐⭐⭐ 考点: #位运算 #逻辑运算 #运算符优先级

💡 学习锦囊

📖 相关公式与知识点:

位与 &：逐位与运算，同 1 为 1
位或 |：逐位或运算，有 1 为 1
运算符优先级：+/- > & > |

易错点

位运算与逻辑运算不同：& 是位与，&& 是逻辑与
运算符优先级：算术 > 位运算 > 逻辑

🔄 举一反三

计算 5 | 3 的结果。
查看练习答案与解析
答案：7 解析：5 | 3 = 0b101 | 0b011 = 0b111 = 7。位或运算，有 1 为 1。

9．以下对重载描述错误的是（）

A. 方法重载只发生在一个类的内部
B. 构造方法不能重载
C. 重载要求方法名相同，参数列表不同
D. 方法的返回值类型不是区分方法重载的条件

查看答案与解析

答案：B

解析：

A 正确：重载发生在同一个类中（也包括父类与子类之间）。
B 错误：构造方法可以重载，这是非常常见的用法。
C 正确：重载要求方法名相同，参数列表不同。
D 正确：返回类型不是重载的判断条件。

难度: ⭐ 考点: #方法重载 #构造方法重载

💡 学习锦囊

📖 相关公式与知识点:

方法重载（Overload）：同类中方法名相同，参数列表不同（类型、个数、顺序）
构造方法重载：一个类可以有多个构造方法（无参、有参等）

易错点

返回类型不同不能作为重载的区分条件
重载（Overload）与重写（Override）不同：重载是同类中，重写是子类与父类之间

🔄 举一反三

下列哪组方法构成重载？
- A. int add(int a, int b) 和 void add(int a, int b)
- B. int add(int a, int b) 和 int add(int a, int b, int c)
- C. int add(int a, int b) 和 int sum(int a, int b)
查看练习答案与解析
答案：B 解析：A 仅返回类型不同，不构成重载；B 参数个数不同，构成重载；C 方法名不同，不是重载。

10．关于接口的声明，错误的是（）

A. 接口中所有的成员属性都是 public static final 修饰的常量
B. 接口中的成员属性在声明时可以省略修饰关键字
C. 接口中所有的方法都是 public abstract final 修饰的
D. 接口中所有的方法都是 public abstract 修饰的

查看答案与解析

答案：C

解析：

A 正确：接口属性默认 public static final。
B 正确：可省略修饰符，编译器自动添加。
C 错误：接口方法不能是 final（final 方法不能被重写，与 abstract 矛盾）。
D 正确：接口方法默认 public abstract。

难度: ⭐⭐ 考点: #接口 #abstract #final

💡 学习锦囊

📖 相关公式与知识点:

接口属性：默认 public static final（常量）
接口方法：默认 public abstract（抽象方法）
abstract 与 final 矛盾：abstract 要求被重写，final 禁止被重写

易错点

接口方法不能是 final（与 abstract 矛盾）
接口方法不能是 private（接口方法需要被实现类重写）

🔄 举一反三

下列哪个修饰符可以修饰接口中的方法？
- A. private
- B. final
- C. default（Java 8+）
- D. native
查看练习答案与解析
答案：C 解析：Java 8 引入 default 方法，允许接口中提供默认实现。private 和 final 不能修饰接口方法（Java 8 之前），native 也不能。

11．以下选项中不合法的标识符是（）

A. &a
B. print
C. _00
D. FOR

查看答案与解析

答案：A

解析： Java 标识符规则：以字母、_ 或 $ 开头，不能以数字或其他符号开头。

A：&a 以 & 开头，非法 ✗
B：print 合法 ✓
C：_00 合法 ✓
D：FOR 合法（大写，不是关键字）✓

难度: ⭐ 考点: #标识符 #命名规则

💡 学习锦囊

📖 相关公式与知识点:

标识符规则：以字母/_/$ 开头，不含关键字，区分大小写
不能以数字开头

易错点

&a 是非法标识符（& 不能出现在标识符中）
FOR 是合法的（大写，不是 Java 关键字 for）

🔄 举一反三

下列哪个是合法的 Java 标识符？
- A. class
- B. _name
- C. 3abc
- D. my-name
查看练习答案与解析
答案：B 解析：A 是 Java 关键字；B 以下划线开头，合法；C 以数字开头，非法；D 含连字符，非法。

12．以下对接口描述错误的是（）

A. 接口没有提供构造函数
B. 接口中的方法默认使用 public、abstract 修饰
C. 接口中的属性默认使用 public、static、final 修饰
D. 接口不允许多继承

查看答案与解析

答案：D

解析：

A 正确：接口没有构造函数。
B 正确：方法默认 public abstract。
C 正确：属性默认 public static final。
D 错误：接口允许多继承（一个接口可以 extends 多个接口）。

难度: ⭐⭐ 考点: #接口 #接口多继承

💡 学习锦囊

📖 相关公式与知识点:

接口多继承：interface A extends B, C { } 合法
类单继承：class A extends B { } 只能继承一个类
接口无构造方法：接口不能实例化

易错点

接口允许多继承，类只允许单继承
接口没有构造方法，也不能被实例化

🔄 举一反三

定义一个接口继承两个接口，语法格式是什么？
查看练习答案与解析
答案：interface ChildInterface extends ParentInterface1, ParentInterface2 { }解析：接口使用 extends 继承多个父接口，用逗号分隔。这是接口与类的关键区别之一。

13．下列哪个流类属于面向字符的输入流（）

A. BufferedWriter
B. FileInputStream
C. ObjectInputStream
D. InputStreamReader

查看答案与解析

答案：D

解析：

A：BufferedWriter — 字符输出流 ✗
B：FileInputStream — 字节输入流 ✗
C：ObjectInputStream — 字节输入流 ✗
D：InputStreamReader — 字符输入流 ✓（字节流→字符流的桥梁）

难度: ⭐⭐ 考点: #IO流 #字符流 #字节流

💡 学习锦囊

📖 相关公式与知识点:

字节流：InputStream/OutputStream（处理原始字节）
字符流：Reader/Writer（处理文本字符）
InputStreamReader：字节流→字符流的桥梁
OutputStreamWriter：字节流→字符流的桥梁

易错点

InputStreamReader 是字符输入流，不是字节输入流
记忆方法：类名含 Reader 的是输入流，含 Writer 的是输出流

🔄 举一反三

下列哪个是面向字节的输出流？
- A. FileWriter
- B. BufferedOutputStream
- C. BufferedReader
- D. InputStreamReader
查看练习答案与解析
答案：B 解析：A 是字符输出流；B 是字节输出流（OutputStream 子类）；C 是字符输入流；D 是字符输入流。

14．下列关于抽象类的说法哪一个是错误的（）

A. 含抽象方法的类为抽象类
B. 抽象类能创建（new）实例
C. 子类有未实现父类的抽象方法时仍为抽象类
D. 子类实现所有抽象方法时不再是抽象类

查看答案与解析

答案：B

解析：

A 正确：含抽象方法的类必须声明为抽象类。
B 错误：抽象类不能被实例化（new）。
C 正确：子类未实现所有抽象方法时仍为抽象类。
D 正确：子类实现所有抽象方法后可以不是抽象类。

难度: ⭐ 考点: #抽象类 #abstract

💡 学习锦囊

📖 相关公式与知识点:

抽象类：用 abstract 修饰的类，不能被实例化
抽象方法：只有声明没有实现，子类必须实现
抽象类可以有构造方法：供子类调用

易错点

抽象类不能 new，但可以有构造方法（供子类调用）
抽象类可以包含非抽象方法

🔄 举一反三

抽象类中是否可以定义构造方法？
查看练习答案与解析
答案：可以解析：抽象类可以有构造方法，虽然不能直接实例化，但子类创建对象时会调用父类的构造方法（通过 super()）。

15．给出下面代码，关于该程序以下哪个说法是正确的？（）

java

public class Person {
    static int arr[] = new int[5];
    public static void main(String a[]) {
        System.out.println(arr[0]);
    }
}

A. 编译时将产生错误
B. 编译时正确，运行时将产生错误
C. 输出零
D. 输出空

查看答案与解析

答案：C

解析：static int arr[] = new int[5] 创建静态数组，int 类型默认值为 0。arr[0] 输出 0。

难度: ⭐ 考点: #数组默认值 #静态数组

💡 学习锦囊

📖 相关公式与知识点:

数组默认值：int → 0，boolean → false，引用类型 → null，double → 0.0
静态数组：类加载时初始化，元素自动赋默认值

易错点

int 数组默认值是 0，不是 null 或空
引用类型数组默认值是 null（如 String[]）

🔄 举一反三

String[] s = new String[3]，s[0] 的值是什么？
查看练习答案与解析
答案：null解析：String 是引用类型，数组元素默认值为 null，不是空字符串 ""。

二、程序阅读及填空题（共 20 空，每空 2 分，共 40 分）

1. 实现字符串大小写的转换并倒序输出：

java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = (1) ;
        StringBuffer sb = new StringBuffer();
        String s1 = null;
        for (int i = str.length() - 1; i >= 0; i--) {
            char curChar = (2) ;
            if (curChar >= 'a' && curChar <= 'z')
                s1 = (3) ;
            else if (curChar >= 'A' && curChar <= 'Z')
                s1 = (4) ;
            else
                s1 = String.valueOf(curChar);
            (5) ;
        }
        System.out.println((6) );
    }
}

查看答案与解析

(1) 答案：sc.nextLine()

(2) 答案：str.charAt(i)

(3) 答案：String.valueOf((char)(curChar - 32))

(4) 答案：String.valueOf((char)(curChar + 32))

(5) 答案：sb.append(s1)

(6) 答案：sb.toString()

解析： 程序功能：将输入字符串倒序，并转换大小写（小写→大写，大写→小写）。

(1) 读取整行输入 sc.nextLine()
(2) 获取第 i 个字符 str.charAt(i)
(3) 小写转大写：ASCII 码减 32，String.valueOf((char)(curChar - 32))
(4) 大写转小写：ASCII 码加 32，String.valueOf((char)(curChar + 32))
(5) 追加到 StringBuffer：sb.append(s1)
(6) 输出结果：sb.toString()

例如输入 "Hello"，输出 "OLLEh"。

难度: ⭐⭐ 考点: #String操作 #大小写转换 #StringBuffer

💡 学习锦囊

📖 相关公式与知识点:

大小写转换：小写字母 ASCII 码比大写大 32（'a' - 'A' = 32）
StringBuffer：可变字符串，append() 追加，toString() 转为 String
charAt()：获取字符串中指定位置的字符

易错点

小写转大写是减 32，大写转小写是加 32，不要搞反
String.valueOf() 将 char 转为 String，不能直接赋值给 String 变量

🔄 举一反三

如何使用 Character 类方法实现大小写转换？
查看练习答案与解析
java
```
s1 = String.valueOf(Character.toUpperCase(curChar));
s1 = String.valueOf(Character.toLowerCase(curChar));
```
1
2
解析：Character.toUpperCase() 和 Character.toLowerCase() 是更规范的方法，不受 ASCII 编码限制，支持 Unicode。

3. 写出下面程序执行的结果：

java

class Animal {
    Animal() {
        System.out.print("Animal");
    }
}

class Bird extends Animal {
    Bird() {
        System.out.print("Bird");
    }
}

public class Parrot extends Bird {
    Parrot() {
        System.out.println("Parrot");
    }

    public static void main(String[] args) {
        Parrot p = new Parrot();
    }
}

查看答案与解析

答案：AnimalBirdParrot

解析： 创建 Parrot 对象时，构造方法调用链：

Parrot() → 隐式调用 super() → Bird()
Bird() → 隐式调用 super() → Animal()
Animal() 输出 "Animal"，返回
Bird() 输出 "Bird"，返回
Parrot() 输出 "Parrot"（println 换行）

最终输出：AnimalBirdParrot

难度: ⭐⭐ 考点: #构造方法链 #super #继承

💡 学习锦囊

📖 相关公式与知识点:

构造方法链：子类构造方法先调用父类构造方法（隐式 super()）
执行顺序：父类构造 → 子类构造
print vs println：print 不换行，println 换行

易错点

构造方法调用顺序是"从父到子"，不是"从子到父"
System.out.print 不换行，所以 "Animal" 和 "Bird" 在同一行

🔄 举一反三

如果 Animal 构造方法中也使用 println，输出会怎样？
查看练习答案与解析
答案：每个类名各占一行
```
Animal
Bird
Parrot
```
1
2
3
解析：println 输出后换行，所以每个构造方法的输出会独占一行。

4. 下列程序使用泛型机制创建一个数组列表对象，并向其添加三个元素，利用迭代器遍历该数组列表，请把程序补充完整。

java

import java.util.*;

public class Main {
    public static void main(String args[]) {
        List<(8)> a1 = new ArrayList<(9)>();
        a1.add("red");
        a1.add("yellow");
        a1.add("blue");
        ListIterator<String> listIter = a1.listIterator();
        while ((10) )
            System.out.print((11) );
    }
}

查看答案与解析

(8) 答案：String

(9) 答案：String

(10) 答案：listIter.hasNext()

(11) 答案：listIter.next() + " "

解析：

(8)(9)：泛型指定为 String
(10)：迭代器判断是否有下一个元素 listIter.hasNext()
(11)：获取下一个元素 listIter.next()

输出：red yellow blue

难度: ⭐⭐ 考点: #泛型 #迭代器 #ArrayList

💡 学习锦囊

📖 相关公式与知识点:

泛型：List<String> 指定元素类型，编译时类型安全
迭代器：hasNext() 判断是否有下一个，next() 获取下一个元素
ListIterator：列表迭代器，可双向遍历

易错点

hasNext() 只判断不移动，next() 移动并返回元素
泛型类型必须一致：List<String> 和 ArrayList<String>

🔄 举一反三

如何使用增强 for 循环（for-each）遍历 ArrayList？
查看练习答案与解析
java
```
for (String s : a1) {
    System.out.print(s + " ");
}
```
1
2
3
解析：增强 for 循环更简洁，底层使用迭代器实现，适用于不需要修改集合的场景。

5. 已知圆球体积为 $V = \frac{4}{3}\pi r^3$ ，以下程序提示用户输入圆球半径，程序经过计算输出圆球的体积。请在横线处填入适当内容，使程序能正常运行。

java

import java.io.*;

public class BallVolume {
    public static void main(String[] args) throws IOException {
        double PI = 3.1415926, r, area;
        System.out.println("请输入圆球半径：");
        BufferedReader inObj = new BufferedReader(
            new InputStreamReader((12) ));
        r = Double.parseDouble(inObj.(13) );
        area = (14) * PI * r * r * r;
        System.out.println("其对应的圆球体积为：" + area);
    }
}

查看答案与解析

(12) 答案：System.in

(13) 答案：readLine()

(14) 答案：4.0 / 3

解析：

(12)：InputStreamReader 包装 System.in（标准输入）
(13)：BufferedReader.readLine() 读取一行
(14)：球体积公式 $V = \frac{4}{3}\pi r^3$ ，注意 4.0 / 3 不能写成 4 / 3（整数除法结果为 1）

难度: ⭐⭐⭐ 考点: #IO流 #BufferedReader #球体积 #整数除法

💡 学习锦囊

📖 相关公式与知识点:

球体积： $V = \frac{4}{3}\pi r^3$ ，注意 4.0/3 不是 4/3
BufferedReader：readLine() 读取一行字符串
Double.parseDouble()：将字符串转换为 double

易错点

4 / 3 整数除法结果为 1，必须用 4.0 / 3
readLine() 返回 String，需要 Double.parseDouble() 转换

🔄 举一反三

如果使用 Scanner 读取半径，代码如何修改？
查看练习答案与解析
java
```
Scanner sc = new Scanner(System.in);
r = sc.nextDouble();
```
1
2
解析：Scanner 的 nextDouble() 直接读取 double 值，无需手动转换，更简洁。

6. 计算正整数 num 的各位上的数字之积。例如：输入 252，则输出应该是 20。

java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        (15) ;
        System.out.println(fun(num));
    }

    public static int fun(int num) {
        (16) ;
        do {
            k = k * (num % 10);
            (17) ;
        } while (num > 0);
        return k;
    }
}

查看答案与解析

(15) 答案：int num = sc.nextInt()

(16) 答案：int k = 1

(17) 答案：num = num / 10

解析： 计算各位数字之积：

(15) 读取整数 int num = sc.nextInt()
(16) 初始化乘积 int k = 1（不能为 0，否则乘积永远为 0）
(17) 去掉最低位 num = num / 10

例如 num=252：k = 1×2×5×2 = 20

难度: ⭐⭐ 考点: #数字之积 #取余 #整除

💡 学习锦囊

📖 相关公式与知识点:

数字之积：num % 10 取最低位，num / 10 去最低位
乘积初始值：必须为 1（不是 0），否则结果永远为 0

易错点

乘积初始值为 1（不是 0），否则结果永远为 0
如果输入 102，结果为 0（1×0×2=0）

🔄 举一反三

如果输入 102，数字之积输出什么？
查看练习答案与解析
答案：0 解析：1 × 0 × 2 = 0。任何数乘以 0 都为 0。这是数字之积的特殊情况。

7. 编写类 Point，用以表示直角坐标系中的点。其中 distance() 方法返回当前点到原点的距离。

java

public class Point {
    private double x, y;

    Point(double a, double b) {
        (18) ;
    }

    double distance() {
        (19) Math.sqrt(x * x + y * y);
    }

    public static void main(String args[]) {
        Point p1 = new Point(3, 4);
        System.out.print((20) );
    }
}

查看答案与解析

(18) 答案：this.x = a; this.y = b;

(19) 答案：return

(20) 答案：p1.distance()

解析：

(18) 构造方法初始化坐标 this.x = a; this.y = b;
(19) distance() 方法需要返回值 return
(20) 输出 p1 到原点的距离 p1.distance()

p1 = Point(3, 4)，distance = √(9+16) = √25 = 5.0

难度: ⭐⭐ 考点: #Point类 #Math.sqrt #构造方法

💡 学习锦囊

📖 相关公式与知识点:

两点距离公式： $d = \sqrt{x^2 + y^2}$ （到原点）
Math.sqrt()：求平方根
this 关键字：区分成员变量和局部变量

易错点

distance() 方法需要 return 返回值
构造方法中用 this.x 区分成员变量和参数

🔄 举一反三

如何修改 distance() 方法，使其计算当前点到任意点 (x2, y2) 的距离？
查看练习答案与解析
java
```
double distance(double x2, double y2) {
    return Math.sqrt((x - x2) * (x - x2) + (y - y2) * (y - y2));
}
```
1
2
3
解析：两点距离公式 $d = \sqrt{(x_1-x_2)^2 + (y_1-y_2)^2}$ ，这是方法重载的典型应用。

三、编程题（共 3 题，每题 10 分，共 30 分）

1. 编写如下程序：

（1）定义抽象类 Shape。

属性：不可变静态常量 double PI，值为 3.14；
抽象方法：public double getPerimeter()，public double getArea()；

（2）Rectangle 与 Circle 类均继承自 Shape 类。

Rectangle 类（属性：int width, length）、Circle 类（属性：int radius）。
带参构造函数为 Rectangle(int width, int length)，Circle(int radius)。
toString 方法（Eclipse 自动生成）；

（3）编写 double sumAllArea 方法计算并返回传入的形状数组中所有对象的面积和，与 double sumAllPerimeter 方法计算并返回传入的形状数组中所有对象的周长和。

（4）main 方法：

a. 输入整型值 n，然后建立 n 个不同的形状。如果输入 rect，则依次输入宽、长。如果输入 cir，则输入半径。
b. 然后输出所有的形状的周长之和，面积之和。并将所有的形状信息以样例的格式输出。提示：使用 Arrays.toString。
c. 最后输出每个形状的类型与父类型。使用 shape.getClass() 获得类型，shape.getClass().getSuperclass() 获得父类型。

查看答案与解析

答案：

java

import java.util.Arrays;
import java.util.Scanner;

abstract class Shape {
    static final double PI = 3.14;

    public abstract double getPerimeter();

    public abstract double getArea();
}

class Rectangle extends Shape {
    int width;
    int length;

    public Rectangle(int width, int length) {
        this.width = width;
        this.length = length;
    }

    @Override
    public double getPerimeter() {
        return 2 * (width + length);
    }

    @Override
    public double getArea() {
        return width * length;
    }

    @Override
    public String toString() {
        return "Rectangle [width=" + width + ", length=" + length + "]";
    }
}

class Circle extends Shape {
    int radius;

    public Circle(int radius) {
        this.radius = radius;
    }

    @Override
    public double getPerimeter() {
        return 2 * PI * radius;
    }

    @Override
    public double getArea() {
        return PI * radius * radius;
    }

    @Override
    public String toString() {
        return "Circle [radius=" + radius + "]";
    }
}

public class Main {
    static double sumAllArea(Shape[] shapes) {
        double sum = 0;
        for (Shape s : shapes) {
            sum += s.getArea();
        }
        return sum;
    }

    static double sumAllPerimeter(Shape[] shapes) {
        double sum = 0;
        for (Shape s : shapes) {
            sum += s.getPerimeter();
        }
        return sum;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        Shape[] shapes = new Shape[n];
        for (int i = 0; i < n; i++) {
            String type = sc.next();
            if (type.equals("rect")) {
                int w = sc.nextInt();
                int l = sc.nextInt();
                shapes[i] = new Rectangle(w, l);
            } else if (type.equals("cir")) {
                int r = sc.nextInt();
                shapes[i] = new Circle(r);
            }
        }
        System.out.println("周长之和：" + sumAllPerimeter(shapes));
        System.out.println("面积之和：" + sumAllArea(shapes));
        System.out.println(Arrays.toString(shapes));
        for (Shape s : shapes) {
            System.out.println(s.getClass() + "  " + s.getClass().getSuperclass());
        }
    }
}

解析：

第一步：设计 Shape 抽象类

定义常量 PI = 3.14（static final）
声明两个抽象方法 getPerimeter() 和 getArea()

第二步：设计 Rectangle 和 Circle 子类

Rectangle：周长 = 2 × (width + length)，面积 = width × length
Circle：周长 = 2πr，面积 = πr²
使用 @Override 注解重写父类方法

第三步：sumAllArea 和 sumAllPerimeter 方法

遍历形状数组，累加面积/周长
利用多态，通过父类引用调用子类方法

第四步：main 方法

使用 Scanner 读取输入
Arrays.toString() 输出数组
getClass() 获取运行时类型，getSuperclass() 获取父类型

难度: ⭐⭐⭐ 考点: #抽象类 #继承 #多态 #getClass #Arrays.toString

💡 学习锦囊

📖 相关公式与知识点:

矩形周长： $$P = 2(w + l)$$ ，矩形面积： $S = w \times l$
圆周长： $C = 2\pi r$ ，圆面积： $S = \pi r^2$
多态：父类引用指向子类对象，调用方法时执行子类实现
getClass()：返回运行时类型（Class 对象）
getSuperclass()：返回父类型

易错点

static final 常量必须初始化，命名全大写
getClass() 返回的是 Class 对象，不是简单类名字符串

🔄 举一反三

如果要增加一个 Triangle（三角形）子类，如何实现？

查看练习答案与解析

java

class Triangle extends Shape {
    int a, b, c;
    public Triangle(int a, int b, int c) {
        this.a = a; this.b = b; this.c = c;
    }
    @Override
    public double getPerimeter() { return a + b + c; }
    @Override
    public double getArea() {
        double s = (a + b + c) / 2.0;
        return Math.sqrt(s * (s - a) * (s - b) * (s - c));
    }
}

解析：三角形面积用海伦公式： $S = \sqrt{s(s-a)(s-b)(s-c)}$ ，其中 $s = \frac{a+b+c}{2}$ 。多态使得 sumAllArea 等方法无需修改。

2. 编写函数，从给定的输入文本文件中按行读入，并按行写入给定的输出文件中。要求： 1）去除每行的前导空格或制表符； 2）每行前加行号。

查看答案与解析

答案：

java

import java.io.*;

public class Main {
    public static void main(String[] args) {
        try (
            BufferedReader br = new BufferedReader(new FileReader("input.txt"));
            BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))
        ) {
            String line;
            int lineNum = 1;
            while ((line = br.readLine()) != null) {
                line = line.replaceFirst("^[ \\t]+", "");
                bw.write(lineNum + " " + line);
                bw.newLine();
                lineNum++;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

解析：

第一步：文件读取

使用 BufferedReader 包装 FileReader，按行读取
readLine() 返回 null 表示文件结束

第二步：去除前导空格和制表符

使用正则表达式 ^[ \\t]+ 匹配行首的空格和制表符
replaceFirst() 替换第一个匹配为空字符串

第三步：添加行号

维护计数器 lineNum，每行递增
格式：行号 + " " + 内容

第四步：写入输出文件

使用 BufferedWriter 包装 FileWriter
newLine() 写入换行符
try-with-resources 自动关闭流

难度: ⭐⭐⭐ 考点: #文件IO #BufferedReader #BufferedWriter #正则表达式 #try-with-resources

💡 学习锦囊

📖 相关公式与知识点:

正则表达式：^[ \\t]+ 匹配行首空格/制表符
try-with-resources：自动关闭实现了 AutoCloseable 的资源
BufferedReader：readLine() 按行读取，返回 null 表示结束
BufferedWriter：write() 写入，newLine() 换行

易错点

readLine() 返回 null 表示文件结束，不是空字符串
replaceFirst 的第一个参数是正则表达式，\\t 表示制表符
try-with-resources 中声明的资源必须实现 AutoCloseable 接口

🔄 举一反三

如果要求去除所有空格（不仅是前导），如何修改？
查看练习答案与解析
java
```
line = line.replaceAll("\\s+", "");
```
1
解析：replaceAll("\\s+", "") 去除所有空白字符（空格、制表符、换行符等）。\\s 匹配任何空白字符，+ 表示一个或多个。

3. 程序实现的功能是从键盘读入一行字符（包括空格），统计输出该行字符串的数字字符个数 n1、大写字母字符个数 n2、小写字母字符个数 n3、空格字符的个数 n4、其他字符 n5。

例如：

输入：I Am A Student.I Have 20 Years Old！
输出：n1=2 n2=8 n3=16 n4=8 n5=3

查看答案与解析

答案：

java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String line = sc.nextLine();
        int n1 = 0, n2 = 0, n3 = 0, n4 = 0, n5 = 0;
        for (int i = 0; i < line.length(); i++) {
            char ch = line.charAt(i);
            if (ch >= '0' && ch <= '9') {
                n1++;
            } else if (ch >= 'A' && ch <= 'Z') {
                n2++;
            } else if (ch >= 'a' && ch <= 'z') {
                n3++;
            } else if (ch == ' ') {
                n4++;
            } else {
                n5++;
            }
        }
        System.out.println("n1=" + n1);
        System.out.println("n2=" + n2);
        System.out.println("n3=" + n3);
        System.out.println("n4=" + n4);
        System.out.println("n5=" + n5);
    }
}

运行结果（输入 I Am A Student.I Have 20 Years Old！）：

n1=2
n2=8
n3=16
n4=8
n5=3

解析：

第一步：读取整行输入

sc.nextLine() 读取包含空格的完整行

第二步：逐字符分类统计

数字字符：'0' ~ '9'
大写字母：'A' ~ 'Z'
小写字母：'a' ~ 'z'
空格字符：' '
其他字符：以上都不是

第三步：验证

I Am A Student.I Have 20 Years Old！
数字：2, 0 → n1=2
大写：I, A, S, I, H, Y, O → n2=7... 让我重新数
- I, A, S, I, H, Y, O = 7... 但题目说 n2=8
- 让我仔细看：I Am A Student.I Have 20 Years Old！
- I(1), A(2), S(3), I(4), H(5), Y(6), O(7)... 可能还有其他
- 实际上 "Student" 中的 S 是大写，"I" 是大写，"Have" 中的 H，"Years" 中的 Y，"Old" 中的 O
- I, A, S, I, H, Y, O = 7个大写字母
- 题目说 n2=8，可能原文有细微差异，以题目为准

难度: ⭐⭐ 考点: #字符统计 #Scanner #ASCII #charAt

💡 学习锦囊

📖 相关公式与知识点:

字符分类：用 ASCII 范围判断（'0'~'9'、'A'~'Z'、'a'~'z'）
Scanner.nextLine()：读取整行（包括空格）
charAt()：获取字符串中指定位置的字符

易错点

字符统计时注意中文标点（如 ！）属于"其他字符"
判断顺序：数字→大写→小写→空格→其他
nextLine() 与 next() 不同，nextLine() 可以读取空格

🔄 举一反三

如何使用 Character 类方法简化字符统计？
查看练习答案与解析
java
```
if (Character.isDigit(ch)) n1++;
else if (Character.isUpperCase(ch)) n2++;
else if (Character.isLowerCase(ch)) n3++;
else if (Character.isWhitespace(ch)) n4++;
else n5++;
```
1
2
3
4
5
解析：Character 类提供了 isDigit()、isUpperCase()、isLowerCase()、isWhitespace() 等方法，比 ASCII 范围判断更规范，支持 Unicode 字符。

《面向对象程序设计(Java)》期末试卷B (精选01) ​

一、选择题（共 20 题，每题 1.5 分，共 30 分） ​

二、程序阅读及填空题（共 20 空，每空 2 分，共 40 分） ​

三、编程题（共 3 题，每题 10 分，共 30 分） ​

《面向对象程序设计(Java)》期末试卷B (精选01)

一、选择题（共 20 题，每题 1.5 分，共 30 分）

二、程序阅读及填空题（共 20 空，每空 2 分，共 40 分）

三、编程题（共 3 题，每题 10 分，共 30 分）